/*
  -------------- esercitazione: WSD basata su WordNet --------------

Scrivere un programma che utilizzando la libreria RiTa (o altra equivalente)
permetta la disambiguazione di senso di termini polisemici.

Per esempio, date le due frasi

  1. The house was burnt to ashes while the owner returned.
  2. This table is made of ash wood.

e il termine polisemico 'ash', si vuole ottenere la disambiguazione
del  significato (cenere, frassino) con cui il termine occorre in 1 e 2.


Il programma dovrà:

- preprocessare l'input,

        - ottenendo i lemmi: per es., ashes -> ash con l'ausilio
        dell'accesso a WordNet e del metodo getStems() dell'oggetto RiWordnet;
  
	- ripulendo le frasi delle function words,
          reperibili nell'elenco allegato (function_words.txt).

- accedendo a WordNet, reperire i possibili sensi del termine indicato;
 per ciascuno dei sensi calcolare il punteggio di overlap
 (fra il senso corrente e la frase in questione) secondo l'algoritmo di Lesk.

- determinare il senso con cui occorre il termine indicato nella
 frase corrente (la prima e la seconda, nell'esempio proposto).
 Tale senso sarà determinato come quello che massimizza il punteggio di overlap.

 ------------------------------------------------------------------

 */

package eserciziowordnet;

import java.io.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import rita.wordnet.*;

public class Radicchio {

    public static void main(String[] args) throws IOException {
        
        RiWordnet wordnet = new RiWordnet();
        //String[][] listaTipoStems = getStemsFromWord("ashes");
        //OCCHIO AL GENITIVO SASSONE: inserire uno spazio.
        String stmnt1 = "The house was burnt to ashes while the owner returned.";
        String stmnt2 = "This table is made of ash wood.";
        String polyWord = "ash"; // parola polisemica
        String[] res1;
        String[] res2;
        
        res1 = removeFunctionWords(stmnt1);
        res2 = removeFunctionWords(stmnt2);
    }

    public static String[] removeFunctionWords(String stmnt) throws IOException {
        String nomeFile = "/home/gush/NetBeansProjects/EsercizioWordNet/src/eserciziowordnet/function_words.txt";
        String[] prova = stmnt.toLowerCase().split(" "); //prendo una sentence e inserisco le sue parole in un array di String[]
        String[] res = new String[prova.length];
        String[][] stems = null;
        String fileStringato;
        int i = 0;
        int k = 0;
        Pattern pattern;
        Matcher matcher;

        fileStringato = leggiFile(nomeFile);
        System.out.println(fileStringato);
        while (i < prova.length) {
            pattern = Pattern.compile (prova[i]);
            matcher = pattern.matcher (fileStringato);
            if (!matcher.find ()) {
                System.out.println(prova[i] + " NON è una function word.");
                res[k] = prova[i];
                k++;
            }
            else System.out.println(prova[i] + " è una function word.");
            i++;
        }//fine while
        int nParole = k--; //numero di parole presenti dentro l'array res, vale a dire tutte le parole non-function words.

        //for(i = 0; i < nParole; i++) System.out.println(res[i]);
        return res;
    }

    public static String leggiFile (String nomeFile) throws IOException {
        InputStream is = null;
        InputStreamReader isr = null;

        StringBuffer sb = new StringBuffer ();
        char[] buf = new char[1024];
        int len;

        try
        {
            is = new FileInputStream (nomeFile);
            isr = new InputStreamReader (is);

            while ((len = isr.read (buf)) > 0)
                sb.append (buf, 0, len);

            return sb.toString ();
        }
        finally
        {
            if (isr != null)
                isr.close ();
        }
    }//fine metodo leggiFile

    public static String[][] getStemsFromWord(String word) {
        RiWordnet rw = new RiWordnet();
        String[] wtype = rw.getPos(word);
        String[][] nStems = new String[wtype.length][];

        for(int i = 0; i < wtype.length; i++)
            nStems[i] = rw.getStems(word, wtype[i]);

        
        for(int j = 0; j < nStems.length; j++){
            System.out.println("Al tipo: " + wtype[j]);
            for(int k = 0; k < nStems[j].length; k++)
                System.out.println(nStems[j][k]);
        }

        return nStems;
    }//fine metodo getStemsFromWord


}//fine classe
